package club.banyuan.demo;

import java.util.Scanner;

/**
 * @author edz
 * @version 1.0
 * @date 2020/11/12 3:21 下午
 */
public class homework1 {
    public static void main(String[] args) {
        /**
         * 1.手动输入任意三个数，求三个数的和，差
         */
//        Scanner sc=new Scanner(System.in);
//        System.out.println("请输入第一个数");
//        int num1=sc.nextInt();
//        System.out.println("请输入第二个数");
//        int num2=sc.nextInt();
//        System.out.println("请输入第三个数");
//        int num3=sc.nextInt();
//        int sum=num1+num2+num3;
//        int dsum=num1+(-num2)+(-num3);

        /**
         * 2.求BCD+2F的值
         */
//        0xBCD+0x2F=0xBFC;

        /**
         * 3.10011101  转换成八进制  和十六进制
         */
//        0B10011101=o235=0x9D;

        /**
         * 4.变量的特点
         */

        /**
         * 5.基本类型的运算：一家商场在举行打折促销，所有商品都进行8 折优惠。一
         * 位程序员把这个逻辑写成：
         * short price = ...; // 先计算出原价
         * short realPrice = price * 8 / 10; //再计算出打折之后的价格
         *
         * 问：这段代码是否正确？
         * 如果正确，假设price  为100 ，那计算之后的
         * realPrice值为多少？如果不正确，应该怎么改正？
         */
//        Scanner sc =new Scanner(System.in);
//        System.out.println("请输入原价：");
//        int price=sc.nextInt();
//        int realPrice=price*(8/10);

        /**
         * 6.找错
         * 	void public main(){   //1
         * 			int i=1,j;  //
         * 			float f1=0.1;  //f
         * 			float f2=123;   //f
         * 			long  l1=123141L,l2=88888888888;
         * 			double d1=2e20,d2=124;
         * 			byte b1=1,b2=2,b3=129;
         * 			j=j+10;
         * 			i=i/10;
         * 			i=i*0.1;
         * 			char c1='a',c2=125;
         * 			byte b=b1-b2;
         * 			char c=c1+c2-1;
         * 			float f3=f1+f2;
         * 			float f4=f1+f2*0.1;
         * 			double d=d1*i+j;
         * 			float f=(float)(d1*5+d2);
         *          }
         */

//         public void main( ){   //1
//            int i=1,j;  //
//            float k;
//            float f1=0.1f;  //f
//            float f2=123;   //f
//            long  l1=123141L,l2=88888888888l;
//            double d1=2e20,d2=124;
//            byte b1=1,b2=2,b3=127;
//            j=j+10;
//            i=i/10;
//            float k=i*0.1;
//            char c1='a',c2=125;
//            byte b=(byte)(b1-b2);
//            char c=(char)(c1+c2-1);
//            float f3=f1+f2;
//            float f4=(float)(f1+f2*0.1);
//            double d=d1*i+j;
//            float f=(float)(d1*5+d2);
//        }

        /**
         * 7.已知a,b均是整型变量，写出将a,b两个变量中的值互换的程序
         */
//        int temp,a=2,b=3;
//        temp=a;
//        a=b;
//        b=temp;

        /**
         * 8.写出下列变量a和b的运算结果。
         * int a = 9 / 3;
         * int b = 9 % 2;
         */
//         int a=3;
//         int b=1;

        /**
         * 9.判断代码是否有错误，如有，请修改。
         * float a = 2.1;
         * float b = (double)20.9;
         * int b3 = 210.9f +2.51;
         * int b4 = (int)20.9 + (int)2.51;
         */
//        float a = 2.1f;
//        double b = (double)20.9;
//        int b3 = (int)(210.9f +2.51);
//        int b4 = (int)20.9 + (int)2.51;

        /**
         * 10.给定一个任意的大写字母A~Z，转换为小写字母
         */
//        String string="";
//        string=string.toLowerCase();//大写转小写
//        string=string.toUpperCase();//小写转大写

        /**
         * 11.java的命名规范
         */
//        1.包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。包名统一使用单数形式，但是类名如果有复数含义，类名可以使用复数形式。
//        2.类名、接口名使用UpperCamelCase风格，必须遵从驼峰形式，但以下情形例外：DO/BO/DTO/VO/AO/PO/UID等。
//        3.方法名、参数名、成员变量、局部变量都统一使用lowerCamelCase风格，必须遵从驼峰形式。
//        4.常量命名全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长。
//        5.为了达到代码自解释的目标，任何自定义编程元素在命名时，使用尽量完整的单词组合来表达其意，即要做到“见名知意”。
//        6.定义数组时，类型与中括号紧挨相连
//        7.抽象类命名使用 Abstract 或 Base 开头；异常类命名使用 Exception 结尾；测试类命名以它要测试的类的名称开始，以 Test 结尾。
//        8.杜绝完全不规范的缩写，避免望文不知义。
//        9.如果模块、 接口、类、方法使用了设计模式，在命名时需体现出具体模式
//        说明：将设计模式体现在名字中，有利于阅读者快速理解架构设计理念。
//        10.对于 Service 和 DAO 类，基于 SOA 的理念，暴露出来的服务一定是接口，内部的实现类用Impl 的后缀与接口区别。
//        11.如果是形容能力的接口名称，取对应的形容词为接口名（通常是–able 的形容词）。
//        12.在long或者Long赋值时，数值后使用大写的 L，不能是小写的 l，小写容易跟数字 1 混淆，造成误解。
//        13.不允许任何魔法值（即未经预先定义的常量）直接出现在代码中
//        14.枚举类名带上Enum后缀，枚举成员名称需要全大写，单词间用下划线隔开。

        /**
         * 12.选择题
         */
//       1.在java中下列关于自动类型转换说法正确的是（A）
//        A.基本数据类型和String相加结果一定是字符串型
//        B.char类型和int类型相加结果一定是字符
//        C.double类型可以自动转换为int
//        D.char + int + double +"" 结果一定是double；
//
//       2.下列的哪个赋值语句是不正确的？(A)
//        A）float f = 11.1;
//        B）double d = 5.3E12;
//        C）float  d = 3.14f ;
//        D）double  f=11.1E10f;
//
//       3.运算符优先级别排序正确的是（A）
//        A.由高向低分别是：()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符；
//        B.由高向低分别是：()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符；
//        C.由高向低分别是：()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符；
//        D.由高向低分别是：()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；
//
//       4.变量命名规范说法正确的是（B）
//        A、变量由字母、下划线、数字、$符号随意组成；
//        B、变量不能以数字作为开头；
//        C、A和a在java中是同一个变量；
//        D、不同类型的变量，可以起相同的名字；
//
//       5.类型转换说法错误的是（A）
//        A、不管什么类型的数据都可以进行转换；
//        B、java中的数据类型转换分为：自动类型转换和强制类型转换；
//        C、兼容的数据由低向高赋值时会发生自动类型转换；
//        D、兼容的数据由高向低赋值时需要强制类型转换；
//
//       6.以下类型转换错误的是（B）
//        A、double d=20;int a=(int)d； 
//        B、int a=12+"year"；
//        C、double d=20+3.123；
//        D、String str=23+"ttt"；
//
//       7.以下程序的运行结果是：(B)
//        public class Increment{
//            public static void main(String args[]) {
//                int a;
//                a = 6;
//                System.out.print(a);
//                System.out.print(a++);
//                System.out.print(a);
//            }
//        }
//        A.666
//        B.667
//        C.677
//        D.676

//        多选题
//       8.下面哪种情况可以实现自动转换AC
//        A）byte型转换成int型
//        B）int型转换成byte型
//        C）float型转换成double型                      
//        D）double型转换成float型
//
//       9.下面main()方法的定义哪些是正确的ACD
//        A) public static void main(String args[]) {}  
//        B) public static void main(String[]) {}
//        C) public static void main(String[] args) {}   
//        D) public static void main(String [] x) {}
//
//       10.变量名命名正确的有BD
//        A case； B、s1_66； C、10xf; D、$xf3accp;
//          1、以下划线、字母、美元符开头。
//          2、后面跟下划线、字母、美元符以及数字。
//          3、 没有长度限制（但也不能太长！）。
//          4、对大小写敏感（意思是大小写代表不同含义）
//
//       单选
//       11.JAVA所定义的版本中不包括D
//        A、 JAVA2 EE
//        B、 JAVA2 Card
//        C、 JAVA2 ME
//        D、 JAVA2 HE
//        E、 JAVA2 SE
// 
//       12.下列说法正确的是A
//        A、 JAVA程序的main方法必须写在类里面
//        B、 JAVA程序中可以有多个main方法
//        C、 JAVA程序中类名必须与文件名一样
//        D、 JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
//
//       13.变量命名规范说法正确的是B
//        A、 变量由字母、下划线、数字、$符号随意组成；
//        B、 变量不能以数字作为开头；
//        C、 A和a在java中是同一个变量；
//        D、 不同类型的变量，可以起相同的名字；
// 
//       14.下列javaDoc注释正确的是C
//        A、 /*我爱北京天安门*/
//        B、 //我爱北京天安门*/
//        C、 /**我爱北京天安门*/
//        D、 /*我爱北京天安门**/
// 
//       15.为一个boolean类型变量赋值时，可以使用方式B
//        A、 boolean a = 1;
//        B、 boolean a = (9 >= 10);
//        C、 boolean a="真";
//        D、 boolean a = = false;
// 
//       16.以下不是合法的标识符C
//        A、 STRING
//        B、 x3x;
//        C、 void
//        D、 de$f
// 
//       17.表达式(11+3*8)/4%3的值是D
//        A、 31
//        B、 0
//        C、 1
//        D、 2
//
//        多选
//      18.byte变量的取值范围是(B)  
//        A. 0~65535  B. -128~127   C. -256-255   D.0~32767
//      19.以下选项中正确的有(ACD) 
//        A.int i = 32; B. float f = 45.32; C. double d=3.2; D. double d=9.21D;
//      20.假定x和y为double型，则表达式x=2,y=x+3/2的值是(D)  
//        A. 3.5     B. 3     C.2.0      D. 3.0
//      21.下列代码的执行结果是(D)  
//       public class Beirun{ 
//       public static void main(Stringargs[]){ 
//       int t = 9; 	 int q=5; 
//       System.out.println((t++)*(--q)); 
//       }  }
//       A.40 B.40.0 C. 45 D.36
//      22.下列代码的执行结果是(B)  
//       public class Beirun{ 
//       public static void main(String args[]){ 
//       System.out.println(100%3); 
//       System.out.println(100%3.0); 
//       }  } 
//       A.1和1   B. 1和1.0    C. 1.0和1      D. 1.0和1.0
//      23.下列运算符中，(CD)是布尔逻辑运算符 
//       A.++  B. <<   C. ||   D. &
//      24.下列哪一项不能作为标识符的开始（D） 
//       A.字符 B. 下划线 C. 美元$ D. 数字
//      25.如下哪些字串是Java中的标识符(AE)  
//       A. fieldname   B.super     C.3number   D.#number  E.$number
//      26.如下哪些是Java中有效的关键字（BC） 
//       A.const B.NULL C.false  D.this E.native
//      27.如下哪些是Java中正确的整数表示（A）
//        （友情提示:数字o开头的代表8进制数  0x开头的标识16进制数） 
//       A.22 B.0x22(16进制22) C.022（8进制22） D.22H
//      28.下面的代码段中，执行之后i 和j 的值是什么（C） 
//         inti = 1; int j; j= i++; 
//       A.1, 1       B.1, 2        C.2, 1          D.2, 2
//      29.下面哪些赋值语句是合法的（BCD） 
//       A.float a = 2.0 B.double b = 2.0 C.int c = 2   D.long d = 2
//
//      30.下列表达式1+2+ "aa"+3的值是（B）
//      （A）"12aa3" （B）"3aa3 " （C）"12aa" （D）"aa3"   
//      31.已知y=2, z=3, n=4，则经过n=n+ -y*z/n运算后n的值为（A）。 
//       (A）3 （B）-1 （C）-12 （D）-3  32．
//      32.已知a=2, b=3，则表达式a%b*4%b的值为（A） 
//      （A）2 （B）1 （C）-1 （D）-2   
//      33.已知x=2, y=3, z=4，则经过z- = --y –x--运算后，z的值为（D）
//      （A）1 （B）2 （C）3 （D）4    
//      34.表达式(12==0) && (1/0 < 1)的值为（B）。 
//      （A）true （B）false （C）0 （D）运行时抛出异常   
//      35.设有类型定义short i=32; long j=64; 下面赋值语句中不正确的一个是（B） 
//      （A）j=i; （B）i=j; （C）i=(short)j; （D）j=(long)i; 
//      填空题 
//      1.Java 基本数据类型中整型，字符型分别占用字节数为（4）,（2）. 
//      2、Java 语言中的浮点数根据数据存储长度和数值精度的不同，进一步分为 （float）和（double）两种具体类型，（double）精度高 
//      3、布尔类型常量只有两个（true）和（flase），其中前者表示逻辑真，后者表示逻辑假。 
//      4、java 语言中的各种数据类型之间提供自动转换，如第一种操作数为int，而第二种操作数为double,则其结果是（double）类型。
//      5、Java 程序中的单行注释符是（//） ，多行注释符是（/* */ ），文档注释符（/** */）。 
//      6、（boolean）类型数据不可以做类型转换。
//      7、在Java语言的基本数据类型中，占存储空间最少的类型是（boolean），该类型占用的存储空间为（1）位。
//      8、在Java语言中，浮点类型数据属于实型数据，可以分为 （float）和 （double）两种。 
//      9、Java语言中的数据类型转换包括 （自动类型转换）和（强制自动类型）两种。 
//      9、Java语言中的逻辑与(&& &)和逻辑或(|| |)运算采用（短路）方式进行运算。 
//      10、假设i=10, j=20, k=30，则表达式!(i<j+k) || !(i+10<=j) 的值为（false）。
//      11、若已初始化int型变量a，b和c，则当a是b和c的公约数时为true的逻辑表达式是(b%a==0&&c%a==0)。
//      12、表达式(int)((double)(3)/2)的值是(1)。
//      13、表达式5.3+(int)(8.5+4.6)/3%4的值是(5.3)。
//      14、表达式19/3*3+19%3的值是(19)。
//      15、浮点型数据根据数据存储长度和数值精度的不同，进一步分为 (float)和(double)两种类型。
//      16、使用关键字(Boolean)来定义逻辑变量。
//      17、一个long型数据在内存占(8)个字节。
//      18、表示制表符(水平空格)的字符常量是("\t")。
//      19、表示换行符的字符常量是("\n")。
//      20、定义字符串变量s存储空字符串的表达式是(String s="")。
//      21、已知某一天是一周的第3天(从1开始)，则计算该天之后第n天是一周的第几天的表达式为(3+n%7)。
//      22、已知double x=8.5, y=5.8;则表达式x++>y--值为(true)。
//      23、执行语句int a, b, c; a=1; b=3; c=(a+b>3 ? ++a : b++);后，b的值为(3)。
//      24、语句System.out.println(2/3*4.0);输出(0.0)。
//      25、语句System.out.println(6.0*2/3);输出(4.0)。
//      26、已知字符'1'的Unicode值为49，则语句System.out.println('1'+2);输出(51)。
//      26、语句System.out.println(1+""+2);输出(12)。
//      27、当整型变量n的值不能被13除尽时其值才为false的表达式是(n%13==0)。
//      27、关系运算符的运算结果是(boolean)型数据。
//      28、已知boolean  b1 = true, b2=true, b3=false;则表达式 !b1 && b2 ‖b3的值为(false)。
//      29、已知变量a，b，c和d分别是char，int，long和double型且已初始化，则表达式a+b+c+d的值的类型是(double)。
//      30、若int型变量a和b都是0，则执行语句boolean c = a == 0 || ++b == 0;语句后b的值为(0)。
//      31、若int型变量a和b都是0，则执行语句boolean c = a != 0 && ++b == 0;语句后b的值为(0)
//      32、已知double x = 6.5, y = 6.5;则表达式x++>y--值为(false)。
//      33、若char型变量c存储的是一个大写字母，则输出其对应小写字母的语句是(c=c.toLowerCase())。
//      34、当char型变量c存储的是字母'c'的大小写时才为true的表达式是(c=="c"||c=="C")。
//      35、执行下列程序代码的输出结果是(101111)。
//        int a = 10 ;
//        int i , j ;
//        i = ++a ;
//        j = a--;
//        System.out.print("" + a+ i + j );

        /**
         * 13.编程题
         * 编写Java程序，实现判断变量x是奇数还是偶数。
         * X%2==0?偶数：奇数
         */

        /**
         * 14.从键盘输入一个班5个学生的分数，求和并输出
         */
//        Scanner sc=new Scanner(System.in);
//        System.out.println("请输入第一个同学的分数");
//        int num1=sc.nextInt();
//        System.out.println("请输入第二个同学的分数");
//        int num2=sc.nextInt();
//        System.out.println("请输入第三个同学的分数");
//        int num3=sc.nextInt();
//        System.out.println("请输入第四个同学的分数");
//        int num4=sc.nextInt();
//        System.out.println("请输入第五个同学的分数");
//        int num5=sc.nextInt();
//        int sum=0;
//        sum=num1+num2+num3+num4+num5;
//        System.out.println(sum);

        /**
         * 15.从键盘输入某个十进制整数数，转换成对应的二进制整数并输出
         */
//            Scanner scanner=new Scanner(System.in);
//            System.out.println("请输入一个十进制整数");
//            int num=scanner.nextInt();
//            String st=Integer.toBinaryString(num);

        /**
         * 16.输入一批整数，使用循环求出最大值与最小值，输入0时结束
         */
//            Scanner scanner=new Scanner(System.in);
//            int num;
//            int max=0;
//            int min=0;
//            do {
//                System.out.println("请输入整数（输入0时停止）：");
//                num=scanner.nextInt();
//                if(min==0){
//                    min=num;
//                    max=num;
//                }
//                if(max<num&&num!=0){
//                    max=num;
//                }
//                if (min>num&&num!=0) {
//                    min=num;
//                }
//                if(num==0){
//                    break;
//                }
//            }
//            while(num!=0);{
//                    System.out.println("最大值是："+max+"最小值是："+min);
//            }

        /**
         * 17.找出能被5或6整除，但不能被两者同时整除的数
         */
//        for (int i = 0; i < 100; i++) {
//          if(i%5==0&&i%6==0){
//            continue;
//          }
//        while(i%5==0||i%6==0){
//            System.out.println(i+"能被5或6整除，但不能被两者同时整除。");
//            break;
//        }
//        }

        /**
         * 18.请输入一个任意年份,判断是否是闰年
         */
//        Scanner sc=new Scanner(System.in);
//        System.out.println("请输入年份");
//        int year=sc.nextInt();
//        if (year%4==0 && year%100==0 || year%400==0){
//            System.out.println(year+"是闰年");
//        }else{
//            System.out.println(year+"不是闰年");
//        }

        /**
         * 19. 30以内的随机数,请输入任意一个数,循环10次,
         * 求这个数在随机数范围内出现的次数
         */
//        Scanner sc=new Scanner(System.in);
//        System.out.println("请输入一个数");
//        int num=sc.nextInt();
//        int count=0;
//        int [] ints=new int[10];
//        for(int i=0;i<10;i++) {
//            ints[i]=(int) (Math.random() * 30);
//            if(num==ints[i]){
//                count++;
//            }
////            System.out.println(ints[i]);
//        }
//        System.out.println(num+"在随机范围内出现"+count+"次。");

        /**
         * 20.输入一个正整数，将该数的各位左右反转输出，即输入123，输出321
         */
//        Scanner sc=new Scanner(System.in);
//        System.out.println("请输入一个整数");
//        int num=sc.nextInt();
//        int a=num;
//        int b=0;
//        int newnum=0;
//        int count=0;
//        while(a>=1){
//            a=num/10;
//            count++;
//        }
//        for (int i = 0; i <count; i++) {
//            while(b>=0){
//                b=(num/(1Ei))%10;
//                newnum+=b*(10^(count-1-i));
//                break;
//            }
//        }
//        System.out.println(newnum);

        /**
         * 21.任意输入n行n列的乘法口诀表
         */
//        Scanner sc=new Scanner(System.in);
//        System.out.println("请输入行列数：");
//        int num=sc.nextInt();
//        for (int i=1;i<=num;i++){
//            for (int j = 1; j <=i; j++) {
//                System.out.print(j+"*"+i+"="+i*j+" ");
//            }
//            System.out.println();
//        }

        /**
         * 22.输入三个班，每班10个学生的成绩，求每个班的总分和平均分
         */
//        int [] arr={54,34,22,34,34,45};
//        int sum=0;
//        int average=0;
//        for (int i = 0; i <arr.length ; i++) {
//            sum+=arr[i];
//        }
//            average=sum/arr.length;
//        System.out.println(sum+" "+average);

        /**
         * 23.打印出下面的图案
         * 54321
         * 5432
         * 543
         * 54
         * 5
         */
//        int [] arr={5,4,3,2,1};
//            for (int i = 0; i <5; i++) {
//                for (int j = 0; j <5-i; j++) {
//                System.out.print(arr[j]);
//                }
//            System.out.println();
//            }

        /**
         * 24.定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出
         */
//        int [] arr=new int [10];
//        int max=0;
//        int num=0;
//        for (int i = 0; i <arr.length ; i++) {
//            if(max<arr[i]){
//                max=arr[i];
//                num=i;
//            }
//        }
//        System.out.println("数组中最大数是："+max+"其下标是："+num);

        /**
         * 25.输入10个整数存入数组，然后复制到b数组中输出
         */
//        Scanner sc=new Scanner(System.in);
//        int []arra=new int[10];
//        int []arrb=new int[arra.length];
//        for (int i = 0; i <arra.length ; i++) {
//            System.out.println("请输入第"+(i+1)+"个整数");
//            arra[i]=sc.nextInt();
//            arrb[i]=arra[i];
//        }
//        System.out.println("b数组为：");
//        for (int j = 0; j <arrb.length ; j++) {
//            System.out.print(arrb[j]+" ");
//        }
        /**
         * 26.声明一个int型的数组，循环接收8个学生的成绩，
         * 计算这8个学生的总分及平均分、最高分和最低分
         */
//        Scanner sc=new Scanner(System.in);
//        int [] arr=new int[8];
//        int sum=0;
//        int average=0;
//        int max=0;
//        int min=0;
//        for (int i = 0; i <arr.length; i++) {
//            System.out.println("请输入第"+(i+1)+"个学生的成绩");
//            arr[i]=sc.nextInt();
//        }
//        for (int j = 0; j <arr.length ; j++) {
//            sum+=arr[j];
//        }
//        System.out.println("8个同学的总分为："+sum);
//        for (int k = 0; k <arr.length ; k++) {
//            average=sum/arr.length;
//        }
//        System.out.println("8个同学的平均分为："+average);
//        for (int z = 0; z <arr.length ; z++) {
//            max=arr[0];
//            min=arr[0];
//            if(max<arr[z]){
//                max=arr[z];
//            }
//            if(min>arr[z]){
//                min=arr[z];
//            }
//        }
//        System.out.println("8个同学的最高分为："+max+"，最低分为："+min);

        /**
         * 27.定义一个长度为10的整型数组，循环输入10个整数。
         * 然后将输入一个整数，查找此整数，找到输出下标，没找到给出提示。
         */
//        Scanner sc=new Scanner(System.in);
//        int []arr=new int[10];
//        for (int i = 0; i < arr.length ; i++) {
//            System.out.println("请输入第"+(i+1)+"个整数：");
//            arr[i]=sc.nextInt();
//        }
//        System.out.println("请输入一个整数：");
//        int num=sc.nextInt();
//        for (int j = 0; j <arr.length; j++) {
//        boolean flag=true;
//            if (num==arr[j]){
//                System.out.println("此整数在数组中下标为："+j);
//                flag=false;
//            }
//        if((num!=arr[j])&&(j==arr.length-1)) {
//            System.out.println("此整数不在数组中。。。");
//        }
//        }
        /**
         * 28.在一个数组中找出最大和最小值，并输出它们的位置
         */
//        Scanner sc=new Scanner(System.in);
//        int []arr=new int[5];
//        int max=0;
//        int min =0;
//        int num1=0;
//        int num2=0;
//        for (int i = 0; i <arr.length ; i++) {
//            System.out.println("请输入第"+(i+1)+"个整数：");
//            arr[i]=sc.nextInt();
//        }
//        for (int j = 0; j <arr.length ; j++) {
//            max=arr[0];
//            min=arr[0];
//            if(max<arr[j]){
//                max=arr[j];
//                num1=j;
//            }
//            if(min>arr[j]){
//                min=arr[j];
//                num2=j;
//            }
//        }
//                System.out.println("数组最大值为："+max+"，其位置是："+(num1+1));
//                System.out.println("数组最小值为："+min+"，其位置是："+(num2+1));

        /**
         * 29.有30个0~9之间的数字，分别统计0~9这10个数字分别出现了多少次
         */
//        Scanner sc = new Scanner(System.in);
//        int[] arr = new int[30];
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = (int) (Math.random() * 10);
//        }
//        int count;
//        for (int j = 0; j < 10; j++) {
//            count = 0;
//            for (int k = 0; k < arr.length; k++) {
//                if (j == arr[k]) {
//                    count++;
//                }
//            }
//            System.out.println(j + "这个数字出现了" + count + "次");
//        }

        /**
         * 30.你的程序要读入一系列正整数数据，
         * 输入-1表示输入结束，-1本身不是输入的数据。
         * 程序输出读到的数据中的奇数和偶数的个数。 
         * 输入格式:一系列正整数，整数的范围是（0,100000）。
         * 如果输入-1则表示输入结束。 
         * 输出格式：两个整数，第一个整数表示读入数据中的奇数的个数，
         * 第二个整数表示读入数据中的偶数的个数。两个整数之间以空格分隔。
         */
//        Scanner sc = new Scanner(System.in);
//        int odd = 0;
//        int even = 0;
//        while (true) {
//            System.out.println("请输入正整数(输入-1时停止)：");
//            int num = sc.nextInt();
//            if (num == -1) {
//                break;
//            }
//            if (num % 2 == 0) {
//                even++;
//            } else {
//                odd++;
//            }
//        }
//        System.out.println(odd + " " + even);

        /**
         * 31.数据加密问题
         * 某个公司采用公用电话传递数据信息，数据是小于8位的整数(默认8位)，
         * 为了确保安全，在传递过程中需要加密，加密规则如下： 
         * 首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
         * 87654321   8+5=13%10=3   
         * 最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数， 
         * 然后，把加密后的结果在控制台打印出来
         */
//        int num=37485620;
//        int key=0;
//        String str="";
//        int []arr=new int[8];
//        int temp=0;
//        for (int i = 0; i <arr.length ; i++) {
//        while(i<arr.length){
//            key=(num%10+5)%10;
//            arr[i]=key;
//            num=num/10;
//            break;
//        }
//        }
//        temp=arr[0];
//        arr[0]=arr[arr.length-1];
//        arr[arr.length-1]=temp;
//        for (int j = 0; j <arr.length ; j++) {
//            str+=arr[j];
//        }
//        System.out.println(str);

        int num = 43423;
        int key = 0;
        int key0 = (num % 10 + 5) % 10;
        int nnum = num / 10;
        String str = "";
        while (nnum > 9) {
            key = (nnum % 10 + 5) % 10;
            nnum = nnum / 10;
            str += key;
        }
        int key1 = (nnum % 10 + 5) % 10;
        str = key1 + str + key0;
        System.out.println(str);


        /**
         * 32.公司年销售额求和
         * 某公司按照季度和月份统计的数据如下：单位(万元)
         * 第一季度：22,66,44
         * 第二季度：77,33,88
         * 第三季度：25,45,65
         * 第四季度：11,66,99
         */


    }

}


